home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / sunrpc / svc.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  9KB  |  308 lines
  1. /*
  2.  * linux/include/linux/sunrpc/svc.h
  3.  *
  4.  * RPC server declarations.
  5.  *
  6.  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
  7.  */
  8.  
  9.  
  10. #ifndef SUNRPC_SVC_H
  11. #define SUNRPC_SVC_H
  12.  
  13. #include <linux/in.h>
  14. #include <linux/sunrpc/types.h>
  15. #include <linux/sunrpc/xdr.h>
  16. #include <linux/sunrpc/svcauth.h>
  17. #include <linux/wait.h>
  18. #include <linux/mm.h>
  19.  
  20. /*
  21.  * RPC service.
  22.  *
  23.  * An RPC service is a ``daemon,'' possibly multithreaded, which
  24.  * receives and processes incoming RPC messages.
  25.  * It has one or more transport sockets associated with it, and maintains
  26.  * a list of idle threads waiting for input.
  27.  *
  28.  * We currently do not support more than one RPC program per daemon.
  29.  */
  30. struct svc_serv {
  31.     struct list_head    sv_threads;    /* idle server threads */
  32.     struct list_head    sv_sockets;    /* pending sockets */
  33.     struct svc_program *    sv_program;    /* RPC program */
  34.     struct svc_stat *    sv_stats;    /* RPC statistics */
  35.     spinlock_t        sv_lock;
  36.     unsigned int        sv_nrthreads;    /* # of server threads */
  37.     unsigned int        sv_bufsz;    /* datagram buffer size */
  38.     unsigned int        sv_xdrsize;    /* XDR buffer size */
  39.  
  40.     struct list_head    sv_permsocks;    /* all permanent sockets */
  41.     struct list_head    sv_tempsocks;    /* all temporary sockets */
  42.     int            sv_tmpcnt;    /* count of temporary sockets */
  43.  
  44.     char *            sv_name;    /* service name */
  45. };
  46.  
  47. /*
  48.  * Maximum payload size supported by a kernel RPC server.
  49.  * This is use to determine the max number of pages nfsd is
  50.  * willing to return in a single READ operation.
  51.  */
  52. #define RPCSVC_MAXPAYLOAD    (64*1024u)
  53.  
  54. /*
  55.  * RPC Requsts and replies are stored in one or more pages.
  56.  * We maintain an array of pages for each server thread.
  57.  * Requests are copied into these pages as they arrive.  Remaining
  58.  * pages are available to write the reply into.
  59.  *
  60.  * Pages are sent using ->sendpage so each server thread needs to
  61.  * allocate more to replace those used in sending.  To help keep track
  62.  * of these pages we have a receive list where all pages initialy live,
  63.  * and a send list where pages are moved to when there are to be part
  64.  * of a reply.
  65.  *
  66.  * We use xdr_buf for holding responses as it fits well with NFS
  67.  * read responses (that have a header, and some data pages, and possibly
  68.  * a tail) and means we can share some client side routines.
  69.  *
  70.  * The xdr_buf.head kvec always points to the first page in the rq_*pages
  71.  * list.  The xdr_buf.pages pointer points to the second page on that
  72.  * list.  xdr_buf.tail points to the end of the first page.
  73.  * This assumes that the non-page part of an rpc reply will fit
  74.  * in a page - NFSd ensures this.  lockd also has no trouble.
  75.  *
  76.  * Each request/reply pair can have at most one "payload", plus two pages,
  77.  * one for the request, and one for the reply.
  78.  */
  79. #define RPCSVC_MAXPAGES        ((RPCSVC_MAXPAYLOAD+PAGE_SIZE-1)/PAGE_SIZE + 2)
  80.  
  81. static inline u32 svc_getu32(struct kvec *iov)
  82. {
  83.     u32 val, *vp;
  84.     vp = iov->iov_base;
  85.     val = *vp++;
  86.     iov->iov_base = (void*)vp;
  87.     iov->iov_len -= sizeof(u32);
  88.     return val;
  89. }
  90.  
  91. static inline void svc_ungetu32(struct kvec *iov)
  92. {
  93.     u32 *vp = (u32 *)iov->iov_base;
  94.     iov->iov_base = (void *)(vp - 1);
  95.     iov->iov_len += sizeof(*vp);
  96. }
  97.  
  98. static inline void svc_putu32(struct kvec *iov, u32 val)
  99. {
  100.     u32 *vp = iov->iov_base + iov->iov_len;
  101.     *vp = val;
  102.     iov->iov_len += sizeof(u32);
  103. }
  104.  
  105.     
  106. /*
  107.  * The context of a single thread, including the request currently being
  108.  * processed.
  109.  * NOTE: First two items must be prev/next.
  110.  */
  111. struct svc_rqst {
  112.     struct list_head    rq_list;    /* idle list */
  113.     struct svc_sock *    rq_sock;    /* socket */
  114.     struct sockaddr_in    rq_addr;    /* peer address */
  115.     int            rq_addrlen;
  116.  
  117.     struct svc_serv *    rq_server;    /* RPC service definition */
  118.     struct svc_procedure *    rq_procinfo;    /* procedure info */
  119.     struct auth_ops *    rq_authop;    /* authentication flavour */
  120.     struct svc_cred        rq_cred;    /* auth info */
  121.     struct sk_buff *    rq_skbuff;    /* fast recv inet buffer */
  122.     struct svc_deferred_req*rq_deferred;    /* deferred request we are replaying */
  123.  
  124.     struct xdr_buf        rq_arg;
  125.     struct xdr_buf        rq_res;
  126.     struct page *        rq_argpages[RPCSVC_MAXPAGES];
  127.     struct page *        rq_respages[RPCSVC_MAXPAGES];
  128.     int            rq_restailpage;
  129.     short            rq_argused;    /* pages used for argument */
  130.     short            rq_arghi;    /* pages available in argument page list */
  131.     short            rq_resused;    /* pages used for result */
  132.  
  133.     u32            rq_xid;        /* transmission id */
  134.     u32            rq_prog;    /* program number */
  135.     u32            rq_vers;    /* program version */
  136.     u32            rq_proc;    /* procedure number */
  137.     u32            rq_prot;    /* IP protocol */
  138.     unsigned short
  139.                 rq_secure  : 1;    /* secure port */
  140.  
  141.  
  142.     __u32            rq_daddr;    /* dest addr of request - reply from here */
  143.  
  144.     void *            rq_argp;    /* decoded arguments */
  145.     void *            rq_resp;    /* xdr'd results */
  146.     void *            rq_auth_data;    /* flavor-specific data */
  147.  
  148.     int            rq_reserved;    /* space on socket outq
  149.                          * reserved for this request
  150.                          */
  151.  
  152.     struct cache_req    rq_chandle;    /* handle passed to caches for 
  153.                          * request delaying 
  154.                          */
  155.     /* Catering to nfsd */
  156.     struct auth_domain *    rq_client;    /* RPC peer info */
  157.     struct svc_cacherep *    rq_cacherep;    /* cache info */
  158.     struct knfsd_fh *    rq_reffh;    /* Referrence filehandle, used to
  159.                          * determine what device number
  160.                          * to report (real or virtual)
  161.                          */
  162.  
  163.     wait_queue_head_t    rq_wait;    /* synchronization */
  164. };
  165.  
  166. /*
  167.  * Check buffer bounds after decoding arguments
  168.  */
  169. static inline int
  170. xdr_argsize_check(struct svc_rqst *rqstp, u32 *p)
  171. {
  172.     char *cp = (char *)p;
  173.     struct kvec *vec = &rqstp->rq_arg.head[0];
  174.     return cp - (char*)vec->iov_base <= vec->iov_len;
  175. }
  176.  
  177. static inline int
  178. xdr_ressize_check(struct svc_rqst *rqstp, u32 *p)
  179. {
  180.     struct kvec *vec = &rqstp->rq_res.head[0];
  181.     char *cp = (char*)p;
  182.  
  183.     vec->iov_len = cp - (char*)vec->iov_base;
  184.  
  185.     return vec->iov_len <= PAGE_SIZE;
  186. }
  187.  
  188. static inline int svc_take_page(struct svc_rqst *rqstp)
  189. {
  190.     if (rqstp->rq_arghi <= rqstp->rq_argused)
  191.         return -ENOMEM;
  192.     rqstp->rq_arghi--;
  193.     rqstp->rq_respages[rqstp->rq_resused] =
  194.         rqstp->rq_argpages[rqstp->rq_arghi];
  195.     rqstp->rq_resused++;
  196.     return 0;
  197. }
  198.  
  199. static inline void svc_pushback_allpages(struct svc_rqst *rqstp)
  200. {
  201.         while (rqstp->rq_resused) {
  202.         if (rqstp->rq_respages[--rqstp->rq_resused] == NULL)
  203.             continue;
  204.         rqstp->rq_argpages[rqstp->rq_arghi++] =
  205.             rqstp->rq_respages[rqstp->rq_resused];
  206.         rqstp->rq_respages[rqstp->rq_resused] = NULL;
  207.     }
  208. }
  209.  
  210. static inline void svc_pushback_unused_pages(struct svc_rqst *rqstp)
  211. {
  212.     while (rqstp->rq_resused &&
  213.            rqstp->rq_res.pages != &rqstp->rq_respages[rqstp->rq_resused]) {
  214.  
  215.         if (rqstp->rq_respages[--rqstp->rq_resused] != NULL) {
  216.             rqstp->rq_argpages[rqstp->rq_arghi++] =
  217.                 rqstp->rq_respages[rqstp->rq_resused];
  218.             rqstp->rq_respages[rqstp->rq_resused] = NULL;
  219.         }
  220.     }
  221. }
  222.  
  223. static inline void svc_free_allpages(struct svc_rqst *rqstp)
  224. {
  225.         while (rqstp->rq_resused) {
  226.         if (rqstp->rq_respages[--rqstp->rq_resused] == NULL)
  227.             continue;
  228.         put_page(rqstp->rq_respages[rqstp->rq_resused]);
  229.         rqstp->rq_respages[rqstp->rq_resused] = NULL;
  230.     }
  231. }
  232.  
  233. struct svc_deferred_req {
  234.     u32            prot;    /* protocol (UDP or TCP) */
  235.     struct sockaddr_in    addr;
  236.     struct svc_sock        *svsk;    /* where reply must go */
  237.     struct cache_deferred_req handle;
  238.     int            argslen;
  239.     u32            args[0];
  240. };
  241.  
  242. /*
  243.  * RPC program
  244.  */
  245. struct svc_program {
  246.     u32            pg_prog;    /* program number */
  247.     unsigned int        pg_lovers;    /* lowest version */
  248.     unsigned int        pg_hivers;    /* lowest version */
  249.     unsigned int        pg_nvers;    /* number of versions */
  250.     struct svc_version **    pg_vers;    /* version array */
  251.     char *            pg_name;    /* service name */
  252.     char *            pg_class;    /* class name: services sharing authentication */
  253.     struct svc_stat *    pg_stats;    /* rpc statistics */
  254.     /* Override authentication. NULL means use default */
  255.     int            (*pg_authenticate)(struct svc_rqst *, u32 *);
  256. };
  257.  
  258. /*
  259.  * RPC program version
  260.  */
  261. struct svc_version {
  262.     u32            vs_vers;    /* version number */
  263.     u32            vs_nproc;    /* number of procedures */
  264.     struct svc_procedure *    vs_proc;    /* per-procedure info */
  265.     u32            vs_xdrsize;    /* xdrsize needed for this version */
  266.  
  267.     /* Override dispatch function (e.g. when caching replies).
  268.      * A return value of 0 means drop the request. 
  269.      * vs_dispatch == NULL means use default dispatcher.
  270.      */
  271.     int            (*vs_dispatch)(struct svc_rqst *, u32 *);
  272. };
  273.  
  274. /*
  275.  * RPC procedure info
  276.  */
  277. typedef int    (*svc_procfunc)(struct svc_rqst *, void *argp, void *resp);
  278. struct svc_procedure {
  279.     svc_procfunc        pc_func;    /* process the request */
  280.     kxdrproc_t        pc_decode;    /* XDR decode args */
  281.     kxdrproc_t        pc_encode;    /* XDR encode result */
  282.     kxdrproc_t        pc_release;    /* XDR free result */
  283.     unsigned int        pc_argsize;    /* argument struct size */
  284.     unsigned int        pc_ressize;    /* result struct size */
  285.     unsigned int        pc_count;    /* call count */
  286.     unsigned int        pc_cachetype;    /* cache info (NFS) */
  287.     unsigned int        pc_xdrressize;    /* maximum size of XDR reply */
  288. };
  289.  
  290. /*
  291.  * This is the RPC server thread function prototype
  292.  */
  293. typedef void        (*svc_thread_fn)(struct svc_rqst *);
  294.  
  295. /*
  296.  * Function prototypes.
  297.  */
  298. struct svc_serv *  svc_create(struct svc_program *, unsigned int);
  299. int           svc_create_thread(svc_thread_fn, struct svc_serv *);
  300. void           svc_exit_thread(struct svc_rqst *);
  301. void           svc_destroy(struct svc_serv *);
  302. int           svc_process(struct svc_serv *, struct svc_rqst *);
  303. int           svc_register(struct svc_serv *, int, unsigned short);
  304. void           svc_wake_up(struct svc_serv *);
  305. void           svc_reserve(struct svc_rqst *rqstp, int space);
  306.  
  307. #endif /* SUNRPC_SVC_H */
  308.